#include <QtGui>
#include "areaImagen.h"
#include "imagen.h"
#include "interfazSistema/interfazSistema.h"
#include <qaction.h>
#include <QtGui/QScrollArea>

areaImagen::areaImagen(QWidget *parent)
    : QWidget(parent)
{
    setAttribute(Qt::WA_StaticContents);
    modificado = false;
    zoom=100;
    filtroArchivos = tr("Jpg (*.jpg);;Gif (*.gif);;Png (*.png);;Bmp (*.bmp);;All files (*.*)");
    setMinimumSize ( 400, 400);
    setBaseSize(imgQt.size());
    setGeometry(QRect(QPoint(0,0), imgQt.size()));

    QAction *actioncopiar = new QAction(tr("Copiar"), this);
  //   quitAction->setShortcut(tr("Ctrl+C"));
//     connect(quitAction, SIGNAL(triggered()), qApp, SLOT(quit()));
     addAction(actioncopiar);
     QAction *actionCopiarNueva = new QAction(tr("Copiar en ventana nueva"), this);
//      quitAction->setShortcut(tr("Ctrl+C"));
      connect(actionCopiarNueva, SIGNAL(triggered()), qApp, SLOT(ROI()));
//      addAction(actionCopiarNueva);
      menu = new QMenu(this);
      menu->addAction(actioncopiar);
      menu->addAction(actionCopiarNueva);


}

void areaImagen::modificarArea(IplImage* imagen)
{
    QImage *img;
    img= IplImageToQImage(imagen);
    modificarImagenCv(imagen);

    modificarImagenQt(*img);
    modificado = true;
    QPainter painter(img);
    painter.drawImage(QPoint(0, 0), *img);
    setWindowTitle(nombreArch(archReciente) );
    update();
}

void areaImagen::modificarRutaArchivo(const QString &nombreArchivo)
{
    archReciente = QFileInfo(nombreArchivo).canonicalFilePath();
    setWindowTitle(nombreArch(archReciente) + "[*]");
}

const QString areaImagen::nombreArch(const QString &rutaCompleta)
{
    return QFileInfo(rutaCompleta).fileName();
}

bool areaImagen::mostrarImagen(const QString &nombreArchivo)
{
    if(nombreArchivo.isEmpty() == true){
       return false;
        }
    const char *nombreArchivoCv = nombreArchivo.toStdString().c_str();
    imgCv= cargarImagen(nombreArchivoCv, -1);
    QImage *img;
    img=  IplImageToQImage(obtenerImagenCv());
    imgQt=*img;
    imgCvAux= imgCv;
    modificarRutaArchivo(nombreArchivo);
    modificado = false;
    setWindowTitle(nombreArch(nombreArchivo) + "[*]");
    return true;
}

IplImage* areaImagen::mejorarCalidadImagen(IplImage* img,int filtro)
{
    IplImage* resultado = cvCreateImage( cvGetSize(img), IPL_DEPTH_8U, 3 );

    switch( filtro ){
        case 0:
            cvSmooth( img, resultado, CV_BLUR, 7, 7 );
            break;
        case 1:
            cvSmooth( img, resultado, CV_GAUSSIAN, 7, 7 );
            break;
        case 2:
            cvSmooth( img, resultado, CV_MEDIAN, 7, 7 );
            break;
        case 3:
            cvErode( img, resultado, NULL, 1);
            break;
        case 4:
            cvDilate( img, resultado, NULL, 1);
            break;
        //case 5:
          //  cvFloodFill( resultado, seed_point, color, cvScalarAll(5.0), cvScalarAll(5.0), NULL, 4, NULL );
            //break;
        }
    return resultado;
}

void areaImagen::paintEvent(QPaintEvent *)
{
   QPainter painter(this);
   painter.setRenderHint(QPainter::Antialiasing);
   painter.drawImage(QPoint(0, 0),imgQt );
   if (this->presionado){
       painter.setBrush(QBrush(QColor(0,0,127,127)));
       painter.setPen(QPen(QColor(0,0,255)));
       QSize tam = QSize(segundo.x() - primero.x(), segundo.y() - primero.y()) ;
       painter.drawRect(QRect(primero, tam));
   }
}

///////////////////////////////Guardar///////////////////////////////////////////

bool areaImagen::guardar()
{
    if(estaModificado())//archivoReciente().isEmpty()
        return guardarComo();
    else
        {
        const char *nombreArchivoCv = archivoReciente().toStdString().c_str();
        return guardarImagen(nombreArchivoCv, obtenerImagenCv());
        }
}

bool areaImagen::guardarComo()
{
    QString nombreArchivo = QFileDialog::getSaveFileName(this, tr("Guardar Como"),".",filtroArchivos);
    if(nombreArchivo.isEmpty())
        return false;
      if (! (nombreArchivo.endsWith(".jpg", Qt::CaseInsensitive) || nombreArchivo.endsWith(".gif", Qt::CaseInsensitive) || nombreArchivo.endsWith(".png", Qt::CaseInsensitive) || nombreArchivo.endsWith(".bmp", Qt::CaseInsensitive) ))
            nombreArchivo += ".jpg"; // default
    /////////////////////////
    //    setCurrentFileName(fn);
    ///////////////////
    const char *nombreArchivoCv = nombreArchivo.toStdString().c_str();
    return guardarImagen(nombreArchivoCv  , obtenerImagenCv());
}

bool areaImagen::posibleGuardar()
{
    if (estaModificado()) {
       QMessageBox::StandardButton ret;
       ret = QMessageBox::warning(this, tr("Guardar Como"),
                          tr("La Imagen Ha Sido Modificada.\n"
                             "Desea Guardar los Cambios Efectuados?"),
                          QMessageBox::Save | QMessageBox::Discard
                          | QMessageBox::Cancel);
        if (ret == QMessageBox::Save) {
                    guardar();
        } else if (ret == QMessageBox::Cancel) {
            return false;
        }
    }
    return true;
}

void areaImagen::closeEvent(QCloseEvent *evento)
{
    if (posibleGuardar()) {
        evento->accept();
    } else {
        evento->ignore();
    }
}

QSize areaImagen::sizeHint() const
{
    return this->imgQt.size();
}



IplImage *areaImagen::ROI(/*IplImage* imagen,QPoint puntoA,QPoint puntoB*/)
{
    seleccion= true;
    /*
    IplImage *img=imagen;
    cvSetImageROI(img, cvRect(puntoA.x(),puntoA.y(), puntoB.x(), puntoB.y()));
    IplImage *img2 = cvCreateImage(cvGetSize(img), img->depth, img->nChannels);
    cvCopy(img, img2, NULL);

    modificarImagenCvAux(img2);
    archReciente= "ROI";
    modificarArea(img2);
    cvResetImageROI(img);


    if(!puntoA.isNull() && !puntoB.isNull())
        {
        //QRect ROI;
//        ROI.setBottomLeft(mdiHijoActivo()->primero);
  //      ROI.setBottomRight(mdiHijoActivo()->segundo);

        //IplImage* imagen  = obtenerImagenCvAux();
       // cvSetImageROI(imagen, cvRect(puntoA.x(), puntoA.y(), puntoB.x(),puntoB.y()));
    //    IplImage* ROI = cvCreateImage( cvGetSize(imagen), imagen->depth, imagen->nChannels );

         //cvCreateImage(cvGetSize(imagen), imagen->depth, imagen->nChannels);
       // return ROI;
        }
    else
        {}*/
}

void areaImagen::mousePressEvent(QMouseEvent *event)
{
    this->update(0,0,0,0);
    this->presionado = true;
    this->primero = event->pos();
}

void areaImagen::mouseReleaseEvent(QMouseEvent *event)
{
    this->segundo = event->pos();
    if (this->primero == this->segundo)
        return;
    menu->exec(this->mapToGlobal(this->segundo));

    //this->update();
   // this->update(0,0,0,0);

    // aqui harias la seleccion
    // tendrias que tener en cuenta el factor de zoom
    this->presionado = false;
    this->update();
}

void areaImagen::mouseMoveEvent(QMouseEvent *event)
{
    if (this->presionado){
        this->segundo = event->pos();
        this->update();
    }
}

/////////////////////////////////Fin de Guardar///////////////////////////////////////////

/*
void ImageViewer::zoomIn()
//! [9] //! [10]
{
    scaleImage(1.25);
}

void ImageViewer::zoomOut()
{
    scaleImage(0.8);
}

void ImageViewer::scaleImage(double factor)
//! [23] //! [24]
{
    Q_ASSERT(imageLabel->pixmap());
    scaleFactor *= factor;
    imageLabel->resize(scaleFactor * imageLabel->pixmap()->size());

    adjustScrollBar(scrollArea->horizontalScrollBar(), factor);
    adjustScrollBar(scrollArea->verticalScrollBar(), factor);

    zoomInAct->setEnabled(scaleFactor < 3.0);
    zoomOutAct->setEnabled(scaleFactor > 0.333);
}
*/
